package com.cdelink.xzgy.ftp.util;

import org.springframework.data.redis.core.*;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.TimeUnit;

public class RedisUtil {

    public static final String KEY_USER_ID = "ftpuser:%s";

    //TODO: 是否有必要改为通过配置管理，开发阶段有效期设置为2天
    /**
     * 用户登录过期时间
     */
    public static final long USER_SESSION_IDLE_DURATION = 2 * 24 * 60 * 60L;

    public static final int USER_TOKEN_CACHE_LEN = 8;

    private final RedisTemplate<String, Object> redisTemplate;

    public RedisUtil(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 获取hash类型的数据操作对象
     *
     * @return  hash类型的数据操作对象
     */
    public HashOperations<String, String, Object> hashOperations() {
        return redisTemplate.opsForHash();
    }

    /**
     * 获取字符串类型的数据操作对象
     *
     * @return 字符串类型的数据操作对象
     */
    public ValueOperations<String, Object> valueOperations() {
        return redisTemplate.opsForValue();
    }

    /**
     * 获取链表类型的数据操作对象
     *
     * @return
     */
    public ListOperations<String, Object> listOperations() {
        return redisTemplate.opsForList();
    }

    /**
     * 获取无序集合类型的数据操作对象
     *
     * @return
     */
    public SetOperations<String, Object> setOperations() {
        return redisTemplate.opsForSet();
    }

    /**
     * 获取有序集合类型的数据操作对象
     *
     * @return
     */
    public ZSetOperations<String, Object> zSetOperations() {
        return redisTemplate.opsForZSet();
    }

    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key,long time){
        try {
            if(time>0){
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key){
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key){
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    public void del(String ... key){
        if(key != null && key.length > 0){
            if(key.length==1){
                redisTemplate.delete(key[0]);
            }else{
                redisTemplate.delete(Arrays.asList(key));
            }
        }
    }

    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key){
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        return set(key, value, 0);
    }

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time){
        try {
            if(time > 0){
                valueOperations().set(key, value, time, TimeUnit.SECONDS);
            }else{
                valueOperations().set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 获取redis中所有的key
     *
     * @param str
     * @return
     */
    public Set<String> keys(String str) {
        Set<String> keys = new HashSet<>();
        try {
            keys = redisTemplate.keys(str + "*");
            return keys;
        } catch (Exception e) {
            e.printStackTrace();
            return keys;
        }
    }
}